home *** CD-ROM | disk | FTP | other *** search
/ BBS Toolkit / BBS Toolkit.iso / rbbs_pc / mnt_201.zip / CLEANMSG.C next >
Text File  |  1992-01-05  |  13KB  |  435 lines
  1. /****************************************************************************/
  2. /* CLEANMSG module for RBBSMNT v2.01, a maintenance utility for RBBS-PC     */
  3. /*╒═════════════════════════════ NOTICE ═══════════════════════════════════╕*/
  4. /*│  A limited license is granted to all users of this program to make     │*/
  5. /*│  copies if this program and distribute those copies to other users     │*/
  6. /*│  on the following three conditions:                                    │*/
  7. /*│                                                                        │*/
  8. /*│    1.   This notice is NOT altered, bypassed or removed,               │*/
  9. /*│    2.   The program is not to be distributed to others in modified     │*/
  10. /*│         form. You may make changes for your own non-commercial use     │*/
  11. /*│    3.   No fee is to be charged (or any other consideration received)  │*/
  12. /*│         for copying or distributing these programs without an express  │*/
  13. /*│         written agreement with J. Terpstra, Bamestra RBBS, PO Box 66,  │*/
  14. /*│         Beemster, The Netherlands.                                     │*/
  15. /*│                                                                        │*/
  16. /*│Copyright (C) 1991, 1992 - Jan Terpstra, Bamestra RBBS, The Netherlands.│*/
  17. /*╘════════════════════════════════════════════════════════════════════════╛*/
  18. /****************************************************************************/
  19.  
  20. #include "rbbsmnt.h"                    /* definitions for this program     */
  21. #include "externs.h"                    /* external data references         */
  22. int rcount;                             /* # msgs read                      */
  23. int wcount;                             /* # msgs written                   */
  24. int last_one;
  25.  
  26.   /**************************************************************************/
  27.   /* clean a message file                                                   */
  28.   /**************************************************************************/
  29.  
  30. void cleanmsg(void)
  31. {
  32.    char far *b;
  33.    long msgpos;                         /* file position                    */
  34.    int msg,wrk;                         /* file handles                     */
  35.    int newnum;                          /* new msg number after renum       */
  36.    int j;
  37.    int tot_msgs;
  38.    int do_pip = FALSE;
  39.    int keeps = 0;
  40.  
  41.    size_t bufsize;                      /* buffer size                      */
  42.    char *p;
  43.    int kills = 0;
  44.  
  45.    sprintf(logbuf, "Processing %s.", msgfile);
  46.    writelog(logbuf, 1, 3);
  47.  
  48.    if (use_wrk)
  49.    {
  50.       sprintf(wrkfile, "%s\\RBBSMNT.$$M", wkf);
  51.    }
  52.  
  53.    else
  54.    {
  55.       strcpy(wrkfile, msgfile);
  56.  
  57.       if ((p = strrchr(wrkfile, '.')) == NULL)
  58.       {
  59.          p = wrkfile+strlen(wrkfile);
  60.       }
  61.       sprintf(p, ".$$M");
  62.    }
  63.  
  64.    /*************************************************************************/
  65.    /* open msg file                                                         */
  66.    /*************************************************************************/
  67.  
  68.  
  69.    if ((msg = open(msgfile, O_RDONLY|O_BINARY)) == ERROR)
  70.    {
  71.       sprintf(logbuf, "Error opening %s.", msgfile);
  72.       writelog(logbuf, 1, 0);
  73.       return ;
  74.    }
  75.  
  76.    /*************************************************************************/
  77.    /* see if any work to do                                                 */
  78.    /*************************************************************************/
  79.  
  80.  
  81.    if ((tot_msgs = makelist(msg)) == ERROR)/* build list of msgs            */
  82.    {
  83.       close(msg);
  84.       return ;
  85.    }
  86.  
  87.    if (!tot_msgs)                       /* any messages?                    */
  88.    {
  89.       close(msg);
  90.       printf("\r\33[K");
  91.       sprintf(logbuf, "Msgfile is empty.");
  92.       writelog(logbuf, 1, 4);
  93.       close(msg);
  94.       return ;
  95.    }
  96.  
  97.    /*************************************************************************/
  98.    /* first, flag messages to kill by by age                                */
  99.    /*************************************************************************/
  100.  
  101.  
  102.    for (j = 0; j < lives; j++)
  103.    {
  104.  
  105.       if (mlist[j].msg_age > max_age || mlist[j].msg_age < 0)
  106.       {
  107.  
  108.          if (!quiet)
  109.          {
  110.             printf("\r  Msg %05d by date", mlist[j].old_num);
  111.          }
  112.          mlist[j].old_num = -1;         /* set invalid msg number as flag   */
  113.          kills++;
  114.       }
  115.  
  116.       else
  117.       {
  118.          keeps++;                       /* increase keep counter            */
  119.       }
  120.    }
  121.    printf("\r\33[K");
  122.  
  123.    /*************************************************************************/
  124.    /* See if we have left more than the maximum                             */
  125.    /*************************************************************************/
  126.  
  127.    j = 0;
  128.  
  129.    while (keeps > max_msgs && j < lives)
  130.    {
  131.  
  132.       if (mlist[j].old_num != -1)       /* not yet killed?                  */
  133.       {
  134.  
  135.          if (!quiet)
  136.          {
  137.             printf("\r  Msg %05d by amount", mlist[j].old_num);
  138.          }
  139.          mlist[j].old_num = -1;         /* set invalid msg number as flag   */
  140.          kills++;
  141.          keeps--;
  142.       }
  143.       j++;
  144.    }
  145.    printf("\r\33[K");
  146.  
  147.    /*************************************************************************/
  148.    /* any maintenance to do?                                                */
  149.    /*************************************************************************/
  150.  
  151.  
  152.    if (!deads && !bads && !kills && !do_renum)
  153.    {
  154.       sprintf(logbuf, "Msgs: 00000 deleted, %05d active.", lives);
  155.       writelog(logbuf, 1, 4);
  156.       close(msg);
  157.       return ;
  158.    }
  159.  
  160.    /*************************************************************************/
  161.    /* renumber msgs                                                         */
  162.    /*************************************************************************/
  163.  
  164.  
  165.    if (do_renum)
  166.    {
  167.  
  168.       if (quiet)
  169.       {
  170.          printf("\r  Renumbering msgs");
  171.       }
  172.       newnum = 0;
  173.  
  174.       for (j = 0; j < lives; j++)
  175.       {
  176.  
  177.          if (mlist[j].old_num != -1)
  178.          {
  179.             mlist[j].new_num = ++newnum;
  180.  
  181.             if (!quiet)
  182.             {
  183.                printf("\r  Renumber %05d -> %05d", mlist[j].old_num, newnum)
  184.                ;
  185.             }
  186.          }
  187.       }
  188.       printf("\r\33[K");
  189.    }
  190.  
  191.    /*************************************************************************/
  192.    /* open tmp file or same file if PIP                                     */
  193.    /*************************************************************************/
  194.  
  195.  
  196.    if (pip && !bads)
  197.    {
  198.       do_pip = TRUE;
  199.  
  200.       if ((wrk = open(msgfile, O_RDWR|O_BINARY)) == ERROR)
  201.       {
  202.          sprintf(logbuf, "Error opening %s.", msgfile);
  203.          writelog(logbuf, 1, 0);
  204.          return ;
  205.       }
  206.    }
  207.  
  208.    else
  209.    {
  210.  
  211.       if (!access(wrkfile, 0))
  212.       {
  213.          unlink(wrkfile);
  214.       }
  215.  
  216.       if ((wrk = open(wrkfile, O_BINARY|O_WRONLY|O_CREAT, S_IREAD|S_IWRITE))
  217.       == ERROR)
  218.       {
  219.          sprintf(logbuf, "Error opening temporary MESSAGES file.");
  220.          writelog(logbuf, 1, 0);
  221.          return ;
  222.       }
  223.    }
  224.  
  225.    /*************************************************************************/
  226.    /* copy the messages file header if not PIP                              */
  227.    /*************************************************************************/
  228.  
  229.  
  230.    if (do_pip)
  231.    {
  232.       lseek(wrk, (first_rec-1)*128L, SEEK_SET);/* seek workfile to first msg*/
  233.    }
  234.  
  235.    else
  236.    {
  237.       msgpos = 0L;
  238.       bufsize = (size_t)((first_rec-1)*128);
  239.  
  240.       if ((b = (char far *)malloc((size_t)bufsize *sizeof(char))) == NULL)
  241.       {
  242.          sprintf(logbuf, "%s messages buffer.", no_memory);
  243.          writelog(logbuf, 1, 0);
  244.          exit(2);
  245.       }
  246.       lseek(msg, 0L, SEEK_SET);
  247.       lseek(wrk, 0L, SEEK_SET);
  248.       read(msg, b, bufsize);
  249.       write(wrk, b, bufsize);
  250.       free(b);
  251.    }
  252.    next_rec = first_rec;
  253.  
  254.    /*************************************************************************/
  255.    /* need to save old msgs to archive file?                                */
  256.    /*************************************************************************/
  257.  
  258.  
  259.    if (save_em && kills)
  260.    {
  261.       dump_old(msg);
  262.    }
  263.  
  264.    /*************************************************************************/
  265.    /* read all kept messages                                                */
  266.    /*************************************************************************/
  267.  
  268.    wcount = 0;
  269.    rcount = 0;
  270.  
  271.    if (quiet)
  272.    {
  273.       printf("\r\33[K\r  Reading ");
  274.    }
  275.  
  276.    while (rcount < lives)
  277.    {
  278.  
  279.       if (quiet)
  280.       {
  281.  
  282.          if (rcount%32 == 0)
  283.          {
  284.             printf(".");
  285.          }
  286.       }
  287.  
  288.       if (mlist[rcount].old_num == -1)  /* if live msg                      */
  289.       {
  290.          rcount++;
  291.       }
  292.  
  293.       else
  294.       {
  295.          bufsize = mlist[rcount].num_recs *128;/* size of buffer            */
  296.  
  297.          if ((mlist[rcount].buf = (char far *)malloc(bufsize *sizeof(char)))
  298.          != NULL && rcount < lives)     /* allocate buffer                  */
  299.          {
  300.             lseek(msg, mlist[rcount].msg_pos, SEEK_SET);/* seek to msg      */
  301.             read(msg, mlist[rcount].buf, bufsize);/* read msg               */
  302.  
  303.             if (!quiet)
  304.             {
  305.                printf("\r  Reading %05d", mlist[rcount].new_num);
  306.             }
  307.             rcount++;
  308.          }
  309.  
  310.          else
  311.          {
  312.             dump_em(wrk);
  313.  
  314.             if (quiet)
  315.             {
  316.                printf("\r\33[K\r  Reading ");
  317.             }
  318.          }
  319.       }
  320.    }
  321.    dump_em(wrk);
  322.  
  323.    /*************************************************************************/
  324.    /* update msg file header & close files                                  */
  325.    /*************************************************************************/
  326.  
  327.    high_msg = mlist[wcount-1].new_num;
  328.  
  329.    if (!do_pip)
  330.    {
  331.       last_rec = next_rec-1;
  332.    }
  333.  
  334.    else
  335.    {
  336.       memset(logbuf, ' ', 128);
  337.  
  338.       for (j = next_rec; j <= last_rec; j++)
  339.       {
  340.          write(wrk, logbuf, 128);
  341.       }
  342.    }
  343.    put_rbbs_hdr(wrk);
  344.    close(msg);
  345.    close(wrk);
  346.  
  347.    /*************************************************************************/
  348.    /* statistics                                                            */
  349.    /*************************************************************************/
  350.  
  351.    printf("\r\33[K");
  352.    sprintf(logbuf, "Msgs: %05d deleted, %05d active.", kills, keeps);
  353.    writelog(logbuf, 1, 4);
  354.  
  355.    /*************************************************************************/
  356.    /* if PIP, rename or copy workfile to org file                           */
  357.    /*************************************************************************/
  358.  
  359.  
  360.    if (!do_pip)
  361.    {
  362.  
  363.       if (use_wrk)
  364.       {
  365.          sprintf(logbuf, "copy %s %s > nul", wrkfile, msgfile);
  366.          system(logbuf);
  367.          unlink(wrkfile);
  368.       }
  369.  
  370.       else
  371.       {
  372.          unlink(msgfile);
  373.          rename(wrkfile, msgfile);
  374.       }
  375.    }
  376. }
  377.  
  378.  
  379.   /**************************************************************************/
  380.   /* dump this block to disk                                                */
  381.   /**************************************************************************/
  382.  
  383. void dump_em(int fh)
  384. {
  385.    size_t bufsize;
  386.  
  387.  
  388.    if (quiet)
  389.    {
  390.       printf("\r  Writing ");
  391.    }
  392.  
  393.    while (wcount < rcount)
  394.    {
  395.  
  396.       if (quiet)
  397.       {
  398.  
  399.          if (wcount%32 == 0)
  400.          {
  401.             printf("o");
  402.          }
  403.       }
  404.  
  405.       if (mlist[wcount].old_num != -1)
  406.       {
  407.  
  408.          if (!quiet)
  409.          {
  410.             printf("\r  Writing %05d", mlist[wcount].new_num);
  411.          }
  412.  
  413.          /*******************************************************************/
  414.          /* write one msg                                                   */
  415.          /*******************************************************************/
  416.  
  417.  
  418.          if (do_renum)
  419.          {
  420.             itos(mlist[wcount].new_num, mlist[wcount].buf+1, 4);
  421.          }
  422.          last_one = mlist[wcount].new_num;
  423.          next_rec += mlist[wcount].num_recs;
  424.          bufsize = mlist[wcount].num_recs *128;
  425.          write(fh, mlist[wcount].buf, bufsize);/* write                     */
  426.          free(mlist[wcount].buf);       /* free buffer                      */
  427.       }
  428.       wcount++;
  429.    }
  430. }
  431.  
  432.  
  433. /*--------------------------------------------------------------------------*/
  434.  
  435.